Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: Altinn/app-frontend-react#0
File: CLAUDE.md:0-0
Timestamp: 2025-08-22T13:53:28.252Z
Learning: Applies to **/*.test.{ts,tsx} : In tests, use `renderWithProviders` from `src/test/renderWithProviders.tsx` to supply required form layout context

src/features/formData/FormDataWrite.tsx (1)

675-702: Fix TypeScript indexing of unknown data in path collector.

Lines 688 and 692 perform element access on data which is typed as unknown. Even with the type guard on line 688, TypeScript still treats data as unknown afterward. Under strict TypeScript configurations (such as noUncheckedIndexedAccess or similar), indexing unknown is a compile error.

Apply this diff to add a safe cast after the type guard:

 function collectMatchingFieldPaths(
   data: unknown,
   fieldParts: string[],
   currentPath: string,
   partIndex: number,
   results: string[],
 ) {
   if (partIndex >= fieldParts.length) {
     results.push(currentPath);
     return;
   }
 
   const part = fieldParts[partIndex];
-  if (typeof data !== 'object' || data === null || data[part] === undefined || data[part] === null) {
+  if (typeof data !== 'object' || data === null) {
     return;
   }
 
-  const nextData = data[part];
+  const container = data as Record<string, unknown>;
+  const nextData = container[part];
+  if (nextData === undefined || nextData === null) {
+    return;
+  }
+
   const nextPath = currentPath ? `${currentPath}.${part}` : part;
 
   if (Array.isArray(nextData)) {
     for (let i = 0; i < nextData.length; i++) {
       collectMatchingFieldPaths(nextData[i], fieldParts, `${nextPath}[${i}]`, partIndex + 1, results);
     }
   } else {
     collectMatchingFieldPaths(nextData, fieldParts, nextPath, partIndex + 1, results);
   }
 }

src/utils/layout/DataModelLocation.tsx (1)

177-188: Fix Biome lint error by replacing reduceRight with a reverse loop.

Biome flags groupContexts.reduceRight for lint/correctness/useJsxKeyInIterable because JSX is returned from an iterable callback. Even though a key is provided, Biome requires a different pattern to satisfy this rule.

Apply this diff to replace the reduceRight with a reverse for-loop:

-  // Recursively nest the providers from outermost to innermost
-  return groupContexts.reduceRight(
-    (child, { groupBinding, rowIndex }) => (
-      <DataModelLocationProvider
-        key={`${groupBinding.dataType}-${groupBinding.field}-${rowIndex}`}
-        groupBinding={groupBinding}
-        rowIndex={rowIndex}
-      >
-        {child}
-      </DataModelLocationProvider>
-    ),
-    children as React.ReactElement,
-  );
+  // Nest the providers from outermost to innermost
+  let wrappedChildren: React.ReactNode = children;
+  for (let i = groupContexts.length - 1; i >= 0; i--) {
+    const { groupBinding, rowIndex } = groupContexts[i];
+    wrappedChildren = (
+      <DataModelLocationProvider
+        key={`${groupBinding.field}-${rowIndex}`}
+        groupBinding={groupBinding}
+        rowIndex={rowIndex}
+      >
+        {wrappedChildren}
+      </DataModelLocationProvider>
+    );
+  }
+  return <>{wrappedChildren}</>;

src/features/formData/FormDataWrite.tsx (1)

816-848: Simplify the lookup condition logic.

The condition on lines 832-833 is somewhat convoluted. Since foundInDataModel already checks lookupTool && (!lookupErr || lookupErr.error !== 'missingProperty'), the subsequent check for lookupErr?.error !== 'missingRepeatingGroup' can be simplified.

Additionally, line 834 uses reference?.field with optional chaining, but we've already confirmed reference is defined on line 826.

Consider this refactor for clarity:

   return useShallowSelector((v) => {
     if (!reference) {
       return emptyArray;
     }
 
-    // When lookupTool is available and doesn't report a missing repeating group error, we know there's no
-    // repeating group structure in this path, so we can return the field as-is.
-    const foundInDataModel = lookupTool && (!lookupErr || lookupErr.error !== 'missingProperty');
-    if (foundInDataModel && lookupErr?.error !== 'missingRepeatingGroup') {
-      return [reference?.field];
+    // When the field exists in the data model and is not part of a repeating group,
+    // we can return the field as-is without enumeration.
+    if (lookupTool && lookupErr?.error !== 'missingRepeatingGroup' && lookupErr?.error !== 'missingProperty') {
+      return [reference.field];
     }
 
     // If lookupTool is not available (e.g., in tests), or if there's a missingRepeatingGroup error,
     // we need to check the actual data to find all matching paths.
     const formData = v.dataModels[reference.dataType]?.debouncedCurrentData;
     if (!formData) {
       return [];
     }
 
     const paths: string[] = [];
     collectMatchingFieldPaths(formData, reference.field.split('.'), '', 0, paths);
     return paths.length === 0 ? [reference.field] : paths.sort();
   });

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro